{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2024-09-19T13:33:52.607997Z",
     "start_time": "2024-09-19T13:33:52.603407Z"
    }
   },
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from datetime import date\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import roc_auc_score\n",
    "import seaborn as sns\n",
    "plt.rcParams['font.sans-serif'] = 'SimHei'\n",
    "plt.rcParams['axes.unicode_minus'] = False"
   ],
   "outputs": [],
   "execution_count": 91
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-19T13:33:52.635006Z",
     "start_time": "2024-09-19T13:33:52.630987Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 用户在2016年1月1日至2016年6月30日之间真实线上线下消费行为，预测用户在2016年7月领取优惠券后15天以内的使用情况。\n",
    "# 预测投放的优惠券是否核销。\n",
    "# 使用优惠券核销预测的平均AUC（ROC曲线下面积）作为评价标准。即对每个优惠券coupon_id单独计算核销预测的AUC值，再对所有优惠券的AUC值求平均作为最终的评价标准\n",
    "\n",
    "# Coupon_id优惠券ID：null表示无优惠券消费，此时Discount_rate和Date_received字段无意义\n",
    "# Discount_rate优惠率：x \\in [0,1]代表折扣率；x:y表示满x减y。单位是元\n",
    "# Distanceuser经常活动的地点离该merchant的最近门店距离是x*500米（如果是连锁店，则取最近的一家门店），x\\in[0,10]；null表示无此信息，0表示低于500米，10表示大于5公里；\n",
    "# Date_received 领取优惠券日期\n",
    "# Date 消费日期：如果Date=null & Coupon_id != null，该记录表示领取优惠券但没有使用，即负样本；如果Date!=null & Coupon_id = null，则表示普通消费日期；如果Date!=null & Coupon_id != null，则表示用优惠券消费日期，即正样本；"
   ],
   "id": "d0e11031481933ff",
   "outputs": [],
   "execution_count": 92
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-19T13:33:54.095977Z",
     "start_time": "2024-09-19T13:33:52.676951Z"
    }
   },
   "cell_type": "code",
   "source": [
    " # 读取数据\n",
    " # 用户线下消费和优惠券领取行为\n",
    "off_train_data = pd.read_csv('ccf_offline_stage1_train.csv',encoding='utf-8')\n",
    "off_test_data = pd.read_csv('ccf_offline_stage1_test_revised.csv',encoding='utf-8')"
   ],
   "id": "a2541f5907218ef2",
   "outputs": [],
   "execution_count": 93
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-19T13:33:54.167905Z",
     "start_time": "2024-09-19T13:33:54.097978Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 空值统计\n",
    "off_train_data.isnull().sum()\n",
    "off_test_data.isnull().sum()\n",
    "# off_train_data.duplicated()"
   ],
   "id": "918ebe3765bea3a9",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "User_id              0\n",
       "Merchant_id          0\n",
       "Coupon_id            0\n",
       "Discount_rate        0\n",
       "Distance         12064\n",
       "Date_received        0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 94
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-19T13:33:54.697483Z",
     "start_time": "2024-09-19T13:33:54.168911Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 查缺补漏\n",
    "# 填充缺失值\n",
    "off_train_data = off_train_data.fillna('null')\n",
    "off_test_data = off_test_data.fillna('null')"
   ],
   "id": "a33ee910f5858532",
   "outputs": [],
   "execution_count": 95
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-19T13:33:55.888952Z",
     "start_time": "2024-09-19T13:33:54.698485Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 去除重复数据\n",
    "off_test_data.drop_duplicates(inplace=True)\n",
    "off_train_data.drop_duplicates(inplace=True)"
   ],
   "id": "f19227be74af0cfb",
   "outputs": [],
   "execution_count": 96
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-19T13:33:55.903346Z",
     "start_time": "2024-09-19T13:33:55.891958Z"
    }
   },
   "cell_type": "code",
   "source": [
    "off_train_data.info()\n",
    "off_train_data.info()"
   ],
   "id": "8777074a1fac478f",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Index: 1716991 entries, 0 to 1754883\n",
      "Data columns (total 7 columns):\n",
      " #   Column         Dtype \n",
      "---  ------         ----- \n",
      " 0   User_id        int64 \n",
      " 1   Merchant_id    int64 \n",
      " 2   Coupon_id      object\n",
      " 3   Discount_rate  object\n",
      " 4   Distance       object\n",
      " 5   Date_received  object\n",
      " 6   Date           object\n",
      "dtypes: int64(2), object(5)\n",
      "memory usage: 104.8+ MB\n",
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Index: 1716991 entries, 0 to 1754883\n",
      "Data columns (total 7 columns):\n",
      " #   Column         Dtype \n",
      "---  ------         ----- \n",
      " 0   User_id        int64 \n",
      " 1   Merchant_id    int64 \n",
      " 2   Coupon_id      object\n",
      " 3   Discount_rate  object\n",
      " 4   Distance       object\n",
      " 5   Date_received  object\n",
      " 6   Date           object\n",
      "dtypes: int64(2), object(5)\n",
      "memory usage: 104.8+ MB\n"
     ]
    }
   ],
   "execution_count": 97
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-19T13:34:25.530833Z",
     "start_time": "2024-09-19T13:33:55.904348Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 用label列标记分类，label的取值为1表示正样本，0表示负样本，-1表示普通用户\n",
    "# 领取优惠券但没有使用，即负样本\n",
    "# 用优惠券消费日期，即正样本\n",
    "# 没有使用优惠券购买 普通用户\n",
    "def label(row):\n",
    "    if row['Date'] != 'null' and row['Date_received'] != 'null':\n",
    "        if row['Coupon_id'] != 'null':\n",
    "            # 优惠券id不为空，表示使用了优惠券购买\n",
    "            # 计算使用优惠券的日期差值\n",
    "            td = pd.to_datetime(row['Date'], format='%Y%m%d') - \\\n",
    "                 pd.to_datetime(row['Date_received'], format='%Y%m%d')\n",
    "            if td <= pd.Timedelta(15, 'D'):  # 判断使用优惠券是否在15天内\n",
    "                return 1\n",
    "            else:\n",
    "                return 0\n",
    "        else:\n",
    "            # 其他情况：优惠券id为null，表示没有使用优惠券购买\n",
    "            return 0\n",
    "    if row['Date'] == 'null' and row['Date_received'] != 'null':\n",
    "        return 0\n",
    "    else:\n",
    "        return -1\n",
    "# 标记label的值达到分类目的\n",
    "off_train_data['label'] = off_train_data.apply(label, axis = 1)\n",
    "off_train_data['label'].value_counts()\n",
    "\n",
    "off_train_data"
   ],
   "id": "d77838f4097f47c6",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "         User_id  Merchant_id Coupon_id Discount_rate Distance Date_received  \\\n",
       "0        1439408         2632      null          null      0.0          null   \n",
       "1        1439408         4663   11002.0        150:20      1.0    20160528.0   \n",
       "2        1439408         2632    8591.0          20:1      0.0    20160217.0   \n",
       "3        1439408         2632    1078.0          20:1      0.0    20160319.0   \n",
       "4        1439408         2632    8591.0          20:1      0.0    20160613.0   \n",
       "...          ...          ...       ...           ...      ...           ...   \n",
       "1754879   212662         3532      null          null      1.0          null   \n",
       "1754880   212662         3021    3739.0          30:1      6.0    20160508.0   \n",
       "1754881   212662         2934      null          null      2.0          null   \n",
       "1754882   752472         7113    1633.0         50:10      6.0    20160613.0   \n",
       "1754883   752472         3621    2705.0          20:5      0.0    20160523.0   \n",
       "\n",
       "               Date  label  \n",
       "0        20160217.0     -1  \n",
       "1              null      0  \n",
       "2              null      0  \n",
       "3              null      0  \n",
       "4              null      0  \n",
       "...             ...    ...  \n",
       "1754879  20160322.0     -1  \n",
       "1754880  20160602.0      0  \n",
       "1754881  20160321.0     -1  \n",
       "1754882        null      0  \n",
       "1754883        null      0  \n",
       "\n",
       "[1716991 rows x 8 columns]"
      ],
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>User_id</th>\n",
       "      <th>Merchant_id</th>\n",
       "      <th>Coupon_id</th>\n",
       "      <th>Discount_rate</th>\n",
       "      <th>Distance</th>\n",
       "      <th>Date_received</th>\n",
       "      <th>Date</th>\n",
       "      <th>label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1439408</td>\n",
       "      <td>2632</td>\n",
       "      <td>null</td>\n",
       "      <td>null</td>\n",
       "      <td>0.0</td>\n",
       "      <td>null</td>\n",
       "      <td>20160217.0</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1439408</td>\n",
       "      <td>4663</td>\n",
       "      <td>11002.0</td>\n",
       "      <td>150:20</td>\n",
       "      <td>1.0</td>\n",
       "      <td>20160528.0</td>\n",
       "      <td>null</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1439408</td>\n",
       "      <td>2632</td>\n",
       "      <td>8591.0</td>\n",
       "      <td>20:1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>20160217.0</td>\n",
       "      <td>null</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1439408</td>\n",
       "      <td>2632</td>\n",
       "      <td>1078.0</td>\n",
       "      <td>20:1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>20160319.0</td>\n",
       "      <td>null</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1439408</td>\n",
       "      <td>2632</td>\n",
       "      <td>8591.0</td>\n",
       "      <td>20:1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>20160613.0</td>\n",
       "      <td>null</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1754879</th>\n",
       "      <td>212662</td>\n",
       "      <td>3532</td>\n",
       "      <td>null</td>\n",
       "      <td>null</td>\n",
       "      <td>1.0</td>\n",
       "      <td>null</td>\n",
       "      <td>20160322.0</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1754880</th>\n",
       "      <td>212662</td>\n",
       "      <td>3021</td>\n",
       "      <td>3739.0</td>\n",
       "      <td>30:1</td>\n",
       "      <td>6.0</td>\n",
       "      <td>20160508.0</td>\n",
       "      <td>20160602.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1754881</th>\n",
       "      <td>212662</td>\n",
       "      <td>2934</td>\n",
       "      <td>null</td>\n",
       "      <td>null</td>\n",
       "      <td>2.0</td>\n",
       "      <td>null</td>\n",
       "      <td>20160321.0</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1754882</th>\n",
       "      <td>752472</td>\n",
       "      <td>7113</td>\n",
       "      <td>1633.0</td>\n",
       "      <td>50:10</td>\n",
       "      <td>6.0</td>\n",
       "      <td>20160613.0</td>\n",
       "      <td>null</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1754883</th>\n",
       "      <td>752472</td>\n",
       "      <td>3621</td>\n",
       "      <td>2705.0</td>\n",
       "      <td>20:5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>20160523.0</td>\n",
       "      <td>null</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1716991 rows × 8 columns</p>\n",
       "</div>"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 98
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-19T13:34:26.272301Z",
     "start_time": "2024-09-19T13:34:25.531836Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 随机抽样，按照正负样例1：1\n",
    "# 对不平衡的二分类数据进行随机抽样，以实现正负样本的均衡\n",
    "# 切片\n",
    "# X 提取特征数据，不包括标签列。\n",
    "# y 提取标签数据，只包括标签列。\n",
    "X = off_train_data.loc[:,off_train_data.columns != 'label']  # 数据\n",
    "y = off_train_data.loc[:,off_train_data.columns == 'label']  # 标签\n",
    "# 获取类1标签的长度\n",
    "count_one_Class = len(off_train_data[off_train_data['label'] == 1])\n",
    "# 获取两类标签的索引\n",
    "one_Class_index = off_train_data[off_train_data['label'] == 1].index\n",
    "zero_Class_index = off_train_data[off_train_data['label'] == 0].index\n",
    "# 随机选择相同数目的索引\n",
    "np.random.seed(25)  # 定义随机种子\n",
    "# 使用 np.random.choice 从标签为0的样本中随机选择与标签为1样本数量相同的样本（random_zero_index）。replace=True 允许重复抽样。\n",
    "random_zero_index = np.array(np.random.choice(zero_Class_index,count_one_Class,replace=True))\n",
    "# 合并模型样本索引\n",
    "sample = np.concatenate([one_Class_index,random_zero_index])\n",
    "# 按照索引获取行\n",
    "off_train_data = off_train_data.loc[sample,:]\n",
    "# 打印结果对比\n",
    "print('label为1的数目：', len(one_Class_index))\n",
    "print('label为0的数目：', len(zero_Class_index))\n",
    "print('总数：', len(one_Class_index) + len(zero_Class_index))\n",
    "print('抽样label为1的数目：', len(one_Class_index))\n",
    "print('随机抽取label为0的数目：', len(random_zero_index))\n",
    "print('抽样总数：', len(one_Class_index) + len(random_zero_index))\n",
    "print('总样本形状：', off_train_data.shape)"
   ],
   "id": "f6ef8b774e88cd",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "label为1的数目： 62153\n",
      "label为0的数目： 953236\n",
      "总数： 1015389\n",
      "抽样label为1的数目： 62153\n",
      "随机抽取label为0的数目： 62153\n",
      "抽样总数： 124306\n",
      "总样本形状： (124306, 8)\n"
     ]
    }
   ],
   "execution_count": 99
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-19T13:34:26.278559Z",
     "start_time": "2024-09-19T13:34:26.273307Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# EDA（Exploratory Data Analysis，探索性数据分析）是数据分析过程中的一个重要步骤，旨在通过可视化和总结性统计分析，深入理解数据的特征和结构。其主要目的包括：\n",
    "# \n",
    "# 数据理解：帮助分析师了解数据的基本性质，如分布、趋势和模式。\n",
    "# \n",
    "# 数据清洗：识别缺失值、异常值和重复数据，为后续分析做好准备。\n",
    "# \n",
    "# 特征分析：探究不同变量之间的关系，发现潜在的相关性或因果关系。\n",
    "# \n",
    "# 可视化：使用各种图表（如直方图、箱体图、散点图等）直观展示数据特征，便于交流和解释。\n",
    "# \n",
    "# 假设生成：为后续建模和分析提供依据，提出新的假设或问题。\n",
    "# \n",
    "# EDA 的常用步骤：\n",
    "# 数据加载和查看：检查数据的基本信息和结构。\n",
    "# 数据描述性统计：计算均值、标准差、四分位数等指标。\n",
    "# 缺失值和异常值处理：识别并处理缺失数据和离群点。\n",
    "# 数据可视化：创建多种图表展示数据特征和分布。\n",
    "# 变量间关系分析：分析变量之间的相关性和交互作用。\n",
    "# 通过 EDA，分析师能够更好地为建模做准备，提高分析结果的有效性和可靠性。"
   ],
   "id": "3690c6937b22f209",
   "outputs": [],
   "execution_count": 100
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-19T13:34:26.975366Z",
     "start_time": "2024-09-19T13:34:26.280071Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 探索性分析EDA\n",
    "# 据探索通常被视为特征工程的一个重要组成部分。通过数据探索，你可以了解数据的分布、缺失值、异常值等，从而为特征选择和创建新特征提供基础。这些发现帮助你更有效地进行特征工程，提升模型性能。\n",
    "off_train_data.value_counts()\n",
    "# 变换距离的类型，缺失值替换为-1\n",
    "off_train_data['Distance'] = off_train_data['Distance'].replace('null', -1).astype(int)\n",
    "off_test_data['Distance'] = off_test_data['Distance'].replace('null', -1).astype(int)\n",
    "print('查看缺失值结果：\\n',off_train_data.isnull().sum())\n",
    "# 描述性统计分析\n",
    "description = off_train_data.describe()\n",
    "# 依次计算极差值、变异系数、四分位数间距\n",
    "# 衡量数据集中分布范围\n",
    "description.loc['range'] = description.loc['max'] - description.loc['min']\n",
    "# 变异系数是标准差与均值的比值，反映数据相对波动性；\n",
    "description.loc['var'] = description.loc['std'] / description.loc['mean']\n",
    "# 上四分位数（75%）与下四分位数（25%）之间的差。这一指标用于衡量数据的集中程度和离散程度，尤其是在数据存在极端值时。\n",
    "description.loc['dis'] = description.loc['75%'] - description.loc['25%']\n",
    "print('描述性统计结果：\\n',np.round(description, 2))  # 保留两位小数\n",
    "# 相关性分析\n",
    "# 相关性分析有助于识别变量之间的关系，帮助你理解数据特征的相互影响。它可以用于特征选择，排除冗余特征，提升模型性能。此外，它还能揭示潜在的因果关系，为后续的深入分析和建模提供指导\n",
    "# corr = off_train_data.corr(method = 'pearson')  # 计算相关系数矩阵\n",
    "# print('相关系数矩阵为：\\n',np.round(corr, 2))  # 保留两位小数\n",
    "# 绘制相关性热力图\n",
    "# plt.subplots(figsize=(10, 10))  # 设置画面大小\n",
    "# sns.heatmap(corr, annot=True, vmax=1, square=True, cmap=\"Blues\")\n",
    "# plt.title('相关性热力图')\n",
    "# plt.show()\n",
    "# 距离箱型图\n",
    "off_train_data['Distance'].isnull().sum()\n",
    "off_test_data['Distance'].isnull().sum()\n",
    "D1 = np.array(off_train_data['Distance'].values)\n",
    "D2 = np.array(off_test_data['Distance'].values)\n",
    "plt.boxplot([D1,D2],labels=('off_train_data','off_test_data'))\n",
    "plt.title('距离箱型图')\n",
    "plt.show()\n",
    "# 箱体图：识别分布特征：显示数据的中位数、四分位数以及范围，有助于理解数据的集中趋势和离散程度。\n",
    "# 发现异常值：通过箱体外的点，容易识别出异常值或离群点。"
   ],
   "id": "fab0083bed2c53c8",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "查看缺失值结果：\n",
      " User_id          0\n",
      "Merchant_id      0\n",
      "Coupon_id        0\n",
      "Discount_rate    0\n",
      "Distance         0\n",
      "Date_received    0\n",
      "Date             0\n",
      "label            0\n",
      "dtype: int64\n",
      "描述性统计结果：\n",
      "           User_id  Merchant_id   Distance     label\n",
      "count   124306.00    124306.00  124306.00  124306.0\n",
      "mean   3693787.05      4075.27       1.87       0.5\n",
      "std    2125191.23      2473.48       3.36       0.5\n",
      "min        236.00         3.00      -1.00       0.0\n",
      "25%    1849676.50      1941.00       0.00       0.0\n",
      "50%    3697501.00      3621.00       0.00       0.5\n",
      "75%    5540370.25      6434.00       2.00       1.0\n",
      "max    7360967.00      8856.00      10.00       1.0\n",
      "range  7360731.00      8853.00      11.00       1.0\n",
      "var          0.58         0.61       1.80       1.0\n",
      "dis    3690693.75      4493.00       2.00       1.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 101
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-19T13:34:27.582478Z",
     "start_time": "2024-09-19T13:34:26.976373Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 属性构造\n",
    "# 定义函数处理折扣率\n",
    "def convertRate(row):\n",
    "    if row == 'null':\n",
    "        return 1.0\n",
    "    elif ':' in str(row):\n",
    "        rows = row.split(':')\n",
    "        return 1.0 - float(rows[1]) / float(rows[0])\n",
    "    else:\n",
    "        return float(row)\n",
    "# 定义函数处理折扣率类型\n",
    "def getDiscountType(row):\n",
    "    if row == -1:\n",
    "        return -1\n",
    "    elif ':' in row:\n",
    "        # 满多少减多少\n",
    "        return 1\n",
    "    else:\n",
    "        # 折扣率\n",
    "        return 0\n",
    "# 定义函数处理满减类型的折扣优惠券\n",
    "def Man_Rate(row):\n",
    "    if row == -1:\n",
    "        return 0\n",
    "    elif ':' in str(row):\n",
    "        rows = row.split(':')\n",
    "        return int(rows[0])\n",
    "    else:\n",
    "        return 0\n",
    "def Jian_Rate(row):\n",
    "    if row == -1:\n",
    "        return 0\n",
    "    elif ':' in str(row):\n",
    "        rows = row.split(':')\n",
    "        return int(rows[1])\n",
    "    else:\n",
    "        return 0\n",
    "# 调用函数构建跟折扣率相关的四个特征属性\n",
    "off_train_data['Dis_rate'] = off_train_data['Discount_rate'].apply(convertRate)\n",
    "off_train_data['Discount_type'] = off_train_data['Discount_rate'].apply(getDiscountType)\n",
    "off_train_data['Discount_man'] = off_train_data['Discount_rate'].apply(Man_Rate)\n",
    "off_train_data['Discount_jian'] = off_train_data['Discount_rate'].apply(Jian_Rate)\n",
    "off_test_data['Dis_rate'] = off_test_data['Discount_rate'].apply(convertRate)\n",
    "off_test_data['Discount_type'] = off_test_data['Discount_rate'].apply(getDiscountType)\n",
    "off_test_data['Discount_man'] = off_test_data['Discount_rate'].apply(Man_Rate)\n",
    "off_test_data['Discount_jian'] = off_test_data['Discount_rate'].apply(Jian_Rate)"
   ],
   "id": "d92492fc801c6485",
   "outputs": [],
   "execution_count": 102
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-19T13:34:27.732881Z",
     "start_time": "2024-09-19T13:34:27.583025Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 根据label标签来提取正、负样本的全部数据\n",
    "data = off_train_data[off_train_data['label'] != -1]\n",
    "data = data.fillna(-1)\n",
    "data['label'].value_counts()"
   ],
   "id": "8ab509acbed5a91a",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "label\n",
       "1    62153\n",
       "0    62153\n",
       "Name: count, dtype: int64"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 103
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-19T13:34:33.069987Z",
     "start_time": "2024-09-19T13:34:27.734394Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\n",
    "# 获取领券日期是星期几，并且构建成特征\n",
    "def getWeekday(row):\n",
    "    if row == 'null':\n",
    "        return row\n",
    "    else:\n",
    "        return date(int(row[0:4]),int(row[4:6]),int(row[6:8])).weekday()+1\n",
    " \n",
    "data['Weekday'] = data['Date_received'].astype(str).apply(getWeekday)\n",
    "off_test_data['Weekday'] = off_test_data['Date_received'].astype(str).apply(getWeekday)\n",
    "# 周六日为类型1，其他为0\n",
    "data['Is_weekend'] = data['Weekday'].apply(lambda x: 1 if x in [6,7] else 0)\n",
    "off_test_data['Is_weekend'] = off_test_data['Weekday'].apply(lambda x: 1 if x in [6,7] else 0)\n",
    "# 跟星期相关的独热编码\n",
    "def One_hot(df):\n",
    "    weekdaycols = ['weekday' + str(i) for i in range(1,8)]\n",
    "    tmpdf = pd.get_dummies(df['Weekday'].replace('null', np.nan))\n",
    "    tmpdf.columns = weekdaycols\n",
    "    df[weekdaycols] = tmpdf\n",
    "    return df\n",
    "data = One_hot(data)\n",
    "off_test_data = One_hot(off_test_data)\n",
    "# 定义函数得到另外相关的三个特征属性\n",
    "def func(data):\n",
    "    # 提取用户使用的优惠券的数量\n",
    "    f = data[['User_id', 'Coupon_id']]\n",
    "    f['rec_coupon'] = 1\n",
    "    f = f.groupby(['User_id']).agg('sum').reset_index()\n",
    " \n",
    "    # 全部优惠券的数目\n",
    "    f1 = data[['Coupon_id']]\n",
    "    l1 = len(f1)\n",
    "    f1['Number_coupon'] = 1\n",
    "    f1 = f1.groupby(['Coupon_id']).agg('sum').reset_index()\n",
    "    # 优惠券的流行度：每一种优惠券占全部优惠券的比例\n",
    "    f1['Coupon_popu'] = f1['Number_coupon']/l1\n",
    " \n",
    "    # 提取用户和商家\n",
    "    f2 = data[['User_id','Merchant_id']]\n",
    "    l2 = len(f2)\n",
    "    # 提取顾客去商家的数量\n",
    "    f2['Number_merchant'] = 1\n",
    "    f2 = f2.groupby(['Merchant_id']).agg('sum').reset_index()\n",
    "    # 商家的受欢迎度：商家的顾客（用户）占全部商家的顾客（用户）的比例\n",
    "    f2['Merchant_popu'] = f2['Number_merchant']/l2\n",
    " \n",
    "    # 合并特征属性\n",
    "    d0 = pd.merge(data, f[['User_id','rec_coupon']], on='User_id')\n",
    "    d1 = pd.merge(d0,f1[['Coupon_id','Coupon_popu']],on='Coupon_id')\n",
    "    d2 = pd.merge(d1,f2[['Merchant_id','Merchant_popu']],on=['Merchant_id'])\n",
    "    return d2\n",
    "# 调用以上函数构建相关的三个特征属性\n",
    "new_data = func(data)\n",
    "new_test_data = func(off_test_data)\n",
    "# 定义函数得到跟距离相关的特征属性\n",
    "def Get_mer_dis(new_data):\n",
    "    # 查看距离的类别数量\n",
    "    new_data['Distance'].value_counts()\n",
    "    # 提取用户-商家距离的数据集\n",
    "    md1 = new_data[new_data.Coupon_id != 'null'][['Merchant_id', 'Distance']]\n",
    "    md1.replace('null', -1, inplace=True)\n",
    "    md1.replace(-1, np.nan, inplace=True)\n",
    "    # 用户-商家的距离最小值\n",
    "    md2 = md1.groupby('Merchant_id').agg('min').reset_index()\n",
    "    md2.rename(columns={'Distance': 'merchant_min_distance'}, inplace=True)\n",
    "    # 用户-商家的距离最大值\n",
    "    md3 = md1.groupby('Merchant_id').agg('max').reset_index()\n",
    "    md3.rename(columns={'Distance': 'merchant_max_distance'}, inplace=True)\n",
    "    # 用户-商品的距离平均值\n",
    "    md4 = md1.groupby('Merchant_id').agg('mean').reset_index()\n",
    "    md4.rename(columns={'Distance': 'merchant_mean_distance'}, inplace=True)\n",
    "    # 用户-离商品的距离中位值\n",
    "    md5 = md1.groupby('Merchant_id').agg('median').reset_index()\n",
    "    md5.rename(columns={'Distance': 'merchant_median_distance'}, inplace=True)\n",
    "    # 将所有特征合并在一起\n",
    "    merchant_feature = pd.merge(md2, md3, on='Merchant_id', how='left')\n",
    "    merchant_feature = pd.merge(merchant_feature, md4, on='Merchant_id', how='left')\n",
    "    merchant_feature = pd.merge(merchant_feature, md5, on='Merchant_id', how='left')\n",
    "    new_data = pd.merge(new_data,merchant_feature,on='Merchant_id',how='left')\n",
    "    return new_data\n",
    "# 调用上边函数构建距离相关的特征属性\n",
    "new_data = Get_mer_dis(new_data)\n",
    "new_test_data = Get_mer_dis(new_test_data)\n",
    "# 距离柱状图\n",
    "x = np.arange(-1,11)\n",
    "dis1 = np.array(new_data['Distance'].value_counts().sort_index())\n",
    "dis2 = np.array(new_test_data['Distance'].value_counts().sort_index())\n",
    "plt.bar(x,dis1,tick_label=x, label='off_train_data', width=0.3)\n",
    "plt.bar(x+0.3,dis2,label='off_test_data',width=0.3)\n",
    "plt.xlabel('距离')\n",
    "plt.ylabel('计数')\n",
    "plt.title('距离计数分布情况')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "# 定义变换距离类型的函数\n",
    "def get_distance_type(row):\n",
    "    # 距离未知\n",
    "    if row == -1:\n",
    "        return -1\n",
    "    # 1千米内\n",
    "    elif row >= 0 and row <= 2:\n",
    "        return 0\n",
    "    # 1.5-2.5千米内\n",
    "    elif row >= 3 and row <= 5:\n",
    "        return 1\n",
    "    # 3-4.5千米内\n",
    "    elif row >= 6 and row <= 9:\n",
    "        return 2\n",
    "    # 5千米\n",
    "    elif row == 10:\n",
    "        return 3\n",
    "# 构建距离类型的特征属性\n",
    "new_data['Distance_type'] = new_data['Distance'].apply(get_distance_type)\n",
    "new_test_data['Distance_type'] = new_test_data['Distance'].apply(get_distance_type)\n",
    "# 新距离类型分布情况\n",
    "new_data['Distance_type'].value_counts()\n",
    "new_test_data['Distance_type'].value_counts()\n",
    "'''\n",
    " 0    84309\n",
    "-1    13858\n",
    " 3    13321\n",
    " 1    11194\n",
    " 2     6108\n",
    "Name: Distance_type, dtype: int64\n",
    "'''\n",
    "# 距离柱状图\n",
    "x1 = np.arange(-1,4)\n",
    "dis_type1 = np.array(new_data['Distance_type'].value_counts().sort_index())\n",
    "dis_type2 = np.array(new_test_data['Distance_type'].value_counts().sort_index())\n",
    "plt.bar(x1,dis_type1,tick_label=x1, label='off_train_data', width=0.3)\n",
    "plt.bar(x1+0.3,dis_type2,label='off_test_data',width=0.3)\n",
    "plt.xlabel('距离类型')\n",
    "plt.ylabel('计数')\n",
    "plt.title('距离类型计数分布情况')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "# 跟距离相关的独热编码\n",
    "def Get_dis_hot(df):\n",
    "    discols = ['Distance' + str(i) for i in range(-1,11)]\n",
    "    tmpdf = pd.get_dummies(df['Distance'].replace('null', np.nan))\n",
    "    tmpdf.columns = discols\n",
    "    df[discols] = tmpdf\n",
    "    return df\n",
    "new_data = Get_dis_hot(new_data)\n",
    "new_test_data = Get_dis_hot(new_test_data)\n",
    "# 集成新的数据集后，对缺失值处理\n",
    "new_data = new_data.fillna(-1)\n",
    "new_test_data = new_test_data.fillna(-1)\n",
    "new_data.isnull().sum()\n",
    "new_test_data.isnull().sum()\n",
    "# 再次保存最终文件，方便下次直接读取进行预测操作\n",
    "new_data.to_csv('./final_new_data.csv')\n",
    "new_test_data.to_csv('./final_new_test_data.csv')\n",
    "# 读取最终保存的文件\n",
    "new_data = pd.read_csv('./final_new_data.csv',index_col=0)\n",
    "new_test_data = pd.read_csv('./final_new_test_data.csv',index_col=0)"
   ],
   "id": "fbb381921ab48c08",
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\31838\\AppData\\Local\\Temp\\ipykernel_30924\\1923390263.py:26: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  f['rec_coupon'] = 1\n",
      "C:\\Users\\31838\\AppData\\Local\\Temp\\ipykernel_30924\\1923390263.py:32: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  f1['Number_coupon'] = 1\n",
      "C:\\Users\\31838\\AppData\\Local\\Temp\\ipykernel_30924\\1923390263.py:41: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  f2['Number_merchant'] = 1\n",
      "C:\\Users\\31838\\AppData\\Local\\Temp\\ipykernel_30924\\1923390263.py:26: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  f['rec_coupon'] = 1\n",
      "C:\\Users\\31838\\AppData\\Local\\Temp\\ipykernel_30924\\1923390263.py:32: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  f1['Number_coupon'] = 1\n",
      "C:\\Users\\31838\\AppData\\Local\\Temp\\ipykernel_30924\\1923390263.py:41: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  f2['Number_merchant'] = 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 104
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-19T13:34:55.174384Z",
     "start_time": "2024-09-19T13:34:33.070989Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 查看属性特征\n",
    "new_data.columns\n",
    "new_test_data.columns\n",
    "# 选取要预测的特征\n",
    "features = ['Dis_rate','Discount_type','Discount_man', 'Discount_jian',\n",
    "            'rec_coupon','Coupon_popu','Merchant_popu','merchant_min_distance',\n",
    "            'merchant_max_distance','merchant_mean_distance','merchant_median_distance',\n",
    "            'Is_weekend','Weekday','weekday1','weekday2','weekday3','weekday4',\n",
    "            'weekday5','weekday6','weekday7']\n",
    "# 提取指定特征属性的数据集，并且划分为训练集和验证集\n",
    "X = new_data[features]\n",
    "y = new_data['label']\n",
    "X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,stratify=y)\n",
    "# 进行网格搜索调参\n",
    "# from sklearn.model_selection import GridSearchCV\n",
    "# param_second_grid = {\n",
    "#     'learning_rate':[0.1,0.11,0.12,0.13],\n",
    "#     'max_depth': [4],\n",
    "#     'n_estimators': [160]\n",
    "# }\n",
    "# grid_second_search = GridSearchCV(estimator = GradientBoostingClassifier(),\n",
    "#                      param_grid = param_second_grid, scoring = 'neg_mean_absolute_error', cv = 3)\n",
    "# grid_second_search.fit(X_train , y_train)\n",
    "# grid_second_search.best_params_\n",
    "'''\n",
    "{'learning_rate': 0.13, 'max_depth': 4, 'n_estimators': 160}\n",
    "'''\n",
    "# 集成学习提升决策树分类模型\n",
    "# n 160 d 4 a 0.8890163692846558 s 0.6836\n",
    "# n 160 d 4 l 0.12 a 0.8902440244868226 s 0.6825\n",
    "GBC_model = GradientBoostingClassifier(n_estimators=160,max_depth=4)\n",
    "GBC_model.fit(X,y)\n",
    "# 预测样本的各类标签（这里是0和1）的概率\n",
    "GBC_model.predict_proba(X_test)\n",
    "# 预测标签为1的概率\n",
    "y_predict = GBC_model.predict_proba(X_test)[:,1]\n",
    "# AUC值，验证集上的性能结果\n",
    "y_auc = roc_auc_score(y_test,y_predict)\n",
    "y_auc"
   ],
   "id": "bd4550c519a56855",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.883650460703165"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 105
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-19T13:34:55.405448Z",
     "start_time": "2024-09-19T13:34:55.176828Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\n",
    "# 绘制 ROC曲线\n",
    "from sklearn import metrics\n",
    "import matplotlib.pyplot as plt\n",
    "# fpr假正率，tpr召回率，thresholds阈值，pos_label（设置正样本值）默认为None（标签数据为二分类的情况）\n",
    "fpr, tpr, thresholds = metrics.roc_curve(y_test, y_predict, pos_label=1)\n",
    "roc_auc = metrics.auc(fpr, tpr)  # auc为Roc曲线下的面积\n",
    "plt.plot(fpr, tpr, 'r')  # 绘制ROC曲线\n",
    "axline = np.array([0.,0.2,0.4,0.6,0.8,1.0])  # 斜线参考线坐标\n",
    "plt.plot(axline,axline,'gray',linestyle='--',alpha=0.5)\n",
    "plt.grid(b=True,axis='both',alpha=0.3)  # 显示网格\n",
    "plt.xlim([-0.05, 1.05])  # 设置x轴刻度范围\n",
    "plt.ylim([-0.05, 1.05])  # 设置y轴刻度范围\n",
    "plt.xlabel('FPR')  # x轴是False Positive Rate\n",
    "plt.ylabel('TPR')  # y轴是True Positive Rate\n",
    "plt.title('AUC = %0.2f' % roc_auc)\n",
    "plt.show()"
   ],
   "id": "720cb2a66a6984fd",
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "keyword grid_b is not recognized; valid keywords are ['size', 'width', 'color', 'tickdir', 'pad', 'labelsize', 'labelcolor', 'labelfontfamily', 'zorder', 'gridOn', 'tick1On', 'tick2On', 'label1On', 'label2On', 'length', 'direction', 'left', 'bottom', 'right', 'top', 'labelleft', 'labelbottom', 'labelright', 'labeltop', 'labelrotation', 'grid_agg_filter', 'grid_alpha', 'grid_animated', 'grid_antialiased', 'grid_clip_box', 'grid_clip_on', 'grid_clip_path', 'grid_color', 'grid_dash_capstyle', 'grid_dash_joinstyle', 'grid_dashes', 'grid_data', 'grid_drawstyle', 'grid_figure', 'grid_fillstyle', 'grid_gapcolor', 'grid_gid', 'grid_in_layout', 'grid_label', 'grid_linestyle', 'grid_linewidth', 'grid_marker', 'grid_markeredgecolor', 'grid_markeredgewidth', 'grid_markerfacecolor', 'grid_markerfacecoloralt', 'grid_markersize', 'grid_markevery', 'grid_mouseover', 'grid_path_effects', 'grid_picker', 'grid_pickradius', 'grid_rasterized', 'grid_sketch_params', 'grid_snap', 'grid_solid_capstyle', 'grid_solid_joinstyle', 'grid_transform', 'grid_url', 'grid_visible', 'grid_xdata', 'grid_ydata', 'grid_zorder', 'grid_aa', 'grid_c', 'grid_ds', 'grid_ls', 'grid_lw', 'grid_mec', 'grid_mew', 'grid_mfc', 'grid_mfcalt', 'grid_ms']",
     "output_type": "error",
     "traceback": [
      "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[1;31mValueError\u001B[0m                                Traceback (most recent call last)",
      "Cell \u001B[1;32mIn[106], line 10\u001B[0m\n\u001B[0;32m      8\u001B[0m axline \u001B[38;5;241m=\u001B[39m np\u001B[38;5;241m.\u001B[39marray([\u001B[38;5;241m0.\u001B[39m,\u001B[38;5;241m0.2\u001B[39m,\u001B[38;5;241m0.4\u001B[39m,\u001B[38;5;241m0.6\u001B[39m,\u001B[38;5;241m0.8\u001B[39m,\u001B[38;5;241m1.0\u001B[39m])  \u001B[38;5;66;03m# 斜线参考线坐标\u001B[39;00m\n\u001B[0;32m      9\u001B[0m plt\u001B[38;5;241m.\u001B[39mplot(axline,axline,\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mgray\u001B[39m\u001B[38;5;124m'\u001B[39m,linestyle\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124m--\u001B[39m\u001B[38;5;124m'\u001B[39m,alpha\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m0.5\u001B[39m)\n\u001B[1;32m---> 10\u001B[0m plt\u001B[38;5;241m.\u001B[39mgrid(b\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mTrue\u001B[39;00m,axis\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mboth\u001B[39m\u001B[38;5;124m'\u001B[39m,alpha\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m0.3\u001B[39m)  \u001B[38;5;66;03m# 显示网格\u001B[39;00m\n\u001B[0;32m     11\u001B[0m plt\u001B[38;5;241m.\u001B[39mxlim([\u001B[38;5;241m-\u001B[39m\u001B[38;5;241m0.05\u001B[39m, \u001B[38;5;241m1.05\u001B[39m])  \u001B[38;5;66;03m# 设置x轴刻度范围\u001B[39;00m\n\u001B[0;32m     12\u001B[0m plt\u001B[38;5;241m.\u001B[39mylim([\u001B[38;5;241m-\u001B[39m\u001B[38;5;241m0.05\u001B[39m, \u001B[38;5;241m1.05\u001B[39m])  \u001B[38;5;66;03m# 设置y轴刻度范围\u001B[39;00m\n",
      "File \u001B[1;32mD:\\Anaconda\\Lib\\site-packages\\matplotlib\\pyplot.py:3144\u001B[0m, in \u001B[0;36mgrid\u001B[1;34m(visible, which, axis, **kwargs)\u001B[0m\n\u001B[0;32m   3137\u001B[0m \u001B[38;5;129m@_copy_docstring_and_deprecators\u001B[39m(Axes\u001B[38;5;241m.\u001B[39mgrid)\n\u001B[0;32m   3138\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mgrid\u001B[39m(\n\u001B[0;32m   3139\u001B[0m     visible: \u001B[38;5;28mbool\u001B[39m \u001B[38;5;241m|\u001B[39m \u001B[38;5;28;01mNone\u001B[39;00m \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mNone\u001B[39;00m,\n\u001B[1;32m   (...)\u001B[0m\n\u001B[0;32m   3142\u001B[0m     \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs,\n\u001B[0;32m   3143\u001B[0m ) \u001B[38;5;241m-\u001B[39m\u001B[38;5;241m>\u001B[39m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[1;32m-> 3144\u001B[0m     gca()\u001B[38;5;241m.\u001B[39mgrid(visible\u001B[38;5;241m=\u001B[39mvisible, which\u001B[38;5;241m=\u001B[39mwhich, axis\u001B[38;5;241m=\u001B[39maxis, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs)\n",
      "File \u001B[1;32mD:\\Anaconda\\Lib\\site-packages\\matplotlib\\axes\\_base.py:3196\u001B[0m, in \u001B[0;36m_AxesBase.grid\u001B[1;34m(self, visible, which, axis, **kwargs)\u001B[0m\n\u001B[0;32m   3194\u001B[0m _api\u001B[38;5;241m.\u001B[39mcheck_in_list([\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mx\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124my\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mboth\u001B[39m\u001B[38;5;124m'\u001B[39m], axis\u001B[38;5;241m=\u001B[39maxis)\n\u001B[0;32m   3195\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m axis \u001B[38;5;129;01min\u001B[39;00m [\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mx\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mboth\u001B[39m\u001B[38;5;124m'\u001B[39m]:\n\u001B[1;32m-> 3196\u001B[0m     \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mxaxis\u001B[38;5;241m.\u001B[39mgrid(visible, which\u001B[38;5;241m=\u001B[39mwhich, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs)\n\u001B[0;32m   3197\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m axis \u001B[38;5;129;01min\u001B[39;00m [\u001B[38;5;124m'\u001B[39m\u001B[38;5;124my\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mboth\u001B[39m\u001B[38;5;124m'\u001B[39m]:\n\u001B[0;32m   3198\u001B[0m     \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39myaxis\u001B[38;5;241m.\u001B[39mgrid(visible, which\u001B[38;5;241m=\u001B[39mwhich, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs)\n",
      "File \u001B[1;32mD:\\Anaconda\\Lib\\site-packages\\matplotlib\\axis.py:1697\u001B[0m, in \u001B[0;36mAxis.grid\u001B[1;34m(self, visible, which, **kwargs)\u001B[0m\n\u001B[0;32m   1694\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m which \u001B[38;5;129;01min\u001B[39;00m [\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mmajor\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mboth\u001B[39m\u001B[38;5;124m'\u001B[39m]:\n\u001B[0;32m   1695\u001B[0m     gridkw[\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mgridOn\u001B[39m\u001B[38;5;124m'\u001B[39m] \u001B[38;5;241m=\u001B[39m (\u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_major_tick_kw[\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mgridOn\u001B[39m\u001B[38;5;124m'\u001B[39m]\n\u001B[0;32m   1696\u001B[0m                         \u001B[38;5;28;01mif\u001B[39;00m visible \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m \u001B[38;5;28;01melse\u001B[39;00m visible)\n\u001B[1;32m-> 1697\u001B[0m     \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mset_tick_params(which\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mmajor\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mgridkw)\n\u001B[0;32m   1698\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mstale \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mTrue\u001B[39;00m\n",
      "File \u001B[1;32mD:\\Anaconda\\Lib\\site-packages\\matplotlib\\axis.py:958\u001B[0m, in \u001B[0;36mAxis.set_tick_params\u001B[1;34m(self, which, reset, **kwargs)\u001B[0m\n\u001B[0;32m    945\u001B[0m \u001B[38;5;250m\u001B[39m\u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[0;32m    946\u001B[0m \u001B[38;5;124;03mSet appearance parameters for ticks, ticklabels, and gridlines.\u001B[39;00m\n\u001B[0;32m    947\u001B[0m \n\u001B[1;32m   (...)\u001B[0m\n\u001B[0;32m    955\u001B[0m \u001B[38;5;124;03m    gridlines.\u001B[39;00m\n\u001B[0;32m    956\u001B[0m \u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[0;32m    957\u001B[0m _api\u001B[38;5;241m.\u001B[39mcheck_in_list([\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mmajor\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mminor\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mboth\u001B[39m\u001B[38;5;124m'\u001B[39m], which\u001B[38;5;241m=\u001B[39mwhich)\n\u001B[1;32m--> 958\u001B[0m kwtrans \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_translate_tick_params(kwargs)\n\u001B[0;32m    960\u001B[0m \u001B[38;5;66;03m# the kwargs are stored in self._major/minor_tick_kw so that any\u001B[39;00m\n\u001B[0;32m    961\u001B[0m \u001B[38;5;66;03m# future new ticks will automatically get them\u001B[39;00m\n\u001B[0;32m    962\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m reset:\n",
      "File \u001B[1;32mD:\\Anaconda\\Lib\\site-packages\\matplotlib\\axis.py:1102\u001B[0m, in \u001B[0;36mAxis._translate_tick_params\u001B[1;34m(kw, reverse)\u001B[0m\n\u001B[0;32m   1100\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m key \u001B[38;5;129;01min\u001B[39;00m kw_:\n\u001B[0;32m   1101\u001B[0m     \u001B[38;5;28;01mif\u001B[39;00m key \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;129;01min\u001B[39;00m allowed_keys:\n\u001B[1;32m-> 1102\u001B[0m         \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\n\u001B[0;32m   1103\u001B[0m             \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mkeyword \u001B[39m\u001B[38;5;132;01m%s\u001B[39;00m\u001B[38;5;124m is not recognized; valid keywords are \u001B[39m\u001B[38;5;132;01m%s\u001B[39;00m\u001B[38;5;124m\"\u001B[39m\n\u001B[0;32m   1104\u001B[0m             \u001B[38;5;241m%\u001B[39m (key, allowed_keys))\n\u001B[0;32m   1105\u001B[0m kwtrans\u001B[38;5;241m.\u001B[39mupdate(kw_)\n\u001B[0;32m   1106\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m kwtrans\n",
      "\u001B[1;31mValueError\u001B[0m: keyword grid_b is not recognized; valid keywords are ['size', 'width', 'color', 'tickdir', 'pad', 'labelsize', 'labelcolor', 'labelfontfamily', 'zorder', 'gridOn', 'tick1On', 'tick2On', 'label1On', 'label2On', 'length', 'direction', 'left', 'bottom', 'right', 'top', 'labelleft', 'labelbottom', 'labelright', 'labeltop', 'labelrotation', 'grid_agg_filter', 'grid_alpha', 'grid_animated', 'grid_antialiased', 'grid_clip_box', 'grid_clip_on', 'grid_clip_path', 'grid_color', 'grid_dash_capstyle', 'grid_dash_joinstyle', 'grid_dashes', 'grid_data', 'grid_drawstyle', 'grid_figure', 'grid_fillstyle', 'grid_gapcolor', 'grid_gid', 'grid_in_layout', 'grid_label', 'grid_linestyle', 'grid_linewidth', 'grid_marker', 'grid_markeredgecolor', 'grid_markeredgewidth', 'grid_markerfacecolor', 'grid_markerfacecoloralt', 'grid_markersize', 'grid_markevery', 'grid_mouseover', 'grid_path_effects', 'grid_picker', 'grid_pickradius', 'grid_rasterized', 'grid_sketch_params', 'grid_snap', 'grid_solid_capstyle', 'grid_solid_joinstyle', 'grid_transform', 'grid_url', 'grid_visible', 'grid_xdata', 'grid_ydata', 'grid_zorder', 'grid_aa', 'grid_c', 'grid_ds', 'grid_ls', 'grid_lw', 'grid_mec', 'grid_mew', 'grid_mfc', 'grid_mfcalt', 'grid_ms']"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 106
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "\n",
    "# 预测给定的测试集\n",
    "pre_test = new_test_data[features]\n",
    "result = GBC_model.predict_proba(pre_test)[:,1]\n",
    "test_result = new_test_data[['User_id','Coupon_id','Date_received']]\n",
    "test_result['Probability'] = result\n",
    "# 查看描述性结果\n",
    "test_result['Probability'].describe()\n",
    "test_result.to_csv('./new_sample_submission.csv',index=None,header=None)"
   ],
   "id": "7ec773e9b496b248",
   "outputs": [],
   "execution_count": null
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
